package com.c2rusthub.service.controller;

import com.c2rusthub.service.model.Task;
import com.c2rusthub.service.model.TaskClaimed;
import com.c2rusthub.service.model.TranslatedTask;
import com.c2rusthub.service.request.ClaimTaskRequest;
import com.c2rusthub.service.request.LikeOrDissRequest;
import com.c2rusthub.service.response.Response;
import com.c2rusthub.service.response.StatusCodeEnum;
import com.c2rusthub.service.response.TaskStatisticsResponse;
import com.c2rusthub.service.service.TaskClaimedService;
import com.c2rusthub.service.service.TaskService;
import com.c2rusthub.service.service.TranslatedService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/decoding-ark")
public class Controller extends BaseController {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    @Autowired
    private TaskService taskService;
    @Autowired
    private TranslatedService translatedService;
    @Autowired
    private TaskClaimedService taskClaimedService;


    // 根据 cUrl 获取任务列表 接口3
    @GetMapping("/curl-task-list")
    public ResponseEntity<Response> getTaskList(@RequestParam String cUrl) {
        return success(taskService.getTaskListByCUrl(cUrl));
    }

    // 根据 cUrl 查询已完成的转译任务列表 接口1
    @GetMapping("/curl-translation-list")
    public ResponseEntity<Response> getTranslatedTasks(@RequestParam String cUrl) {
        // 调用服务层方法，根据 cUrl 获取已完成的转译任务列表
        List<TranslatedTask> translatedTasks = translatedService.getTranslatedTasksByCUrl(cUrl);
        return success(translatedTasks); // 返回成功响应
    }

    // 根据 id 查询已完成转译任务的详情 接口2
    @GetMapping("/{id}/translation-detail")
    public ResponseEntity<Response> getTranslatedTaskDetail(@PathVariable int id) {
        // 调用服务层方法，根据 id 获取已完成的转译任务详情
        TranslatedTask translatedTask = translatedService.getTranslatedTaskById(id);
        if (translatedTask == null) {
            return failure("任务未找到");
        }
        return success(translatedTask); // 返回成功响应
    }

    // 根据 taskId 查询已领转译任务列表 接口4
    @GetMapping("/{taskId}/claim-list")
    public ResponseEntity<Response> getClaimedTaskList(@PathVariable int taskId) {
        // 调用服务层方法，根据 taskId 获取已领转译任务列表
        List<TaskClaimed> claimedTasks = taskClaimedService.getClaimedTasksByTaskId(taskId);
        return success(claimedTasks); // 返回成功响应
    }

    // 根据 taskId 更新转译任务的热度（heat）值 接口5
    @PostMapping("/{taskId}/heat")
    public ResponseEntity<Response> increaseTaskHeat(@PathVariable int taskId) {
        // 调用服务层方法增加任务热度
        boolean success = taskService.increaseTaskHeat(taskId);

        if (success) {
            return success(null); // 成功响应
        } else {
            return failure("任务未找到或更新失败");
        }
    }

    // 根据 taskClaimedId 设置转译任务的状态为完成 接口6
    @PostMapping("/{taskClaimedId}/task-completed")
    public ResponseEntity<Response> markTaskAsCompleted(@PathVariable int taskClaimedId) {
        // 调用服务层方法设置任务为已完成
        boolean success = taskClaimedService.markTaskAsCompleted(taskClaimedId);

        if (success) {
            return success(null); // 成功响应
        } else {
            return failure("任务未找到或更新失败");
        }
    }

    // 发布转译任务 接口7
    @PostMapping("/task/release")
    public ResponseEntity<Response> releaseTask(@RequestBody Task taskReleaseRequest) {
        // 调用服务层方法发布任务
        boolean success = taskService.releaseTask(taskReleaseRequest);

        if (success) {
            return success(null); // 成功响应
        } else {
            return failure("任务发布失败");
        }
    }

    // 查询待认领转译任务数量和已完成转译任务数量 接口8
    @GetMapping("/unclaimed-completed-quantity")
    public ResponseEntity<Response> getTaskStatistics() {
        TaskStatisticsResponse statistics = taskService.getTaskStatistics();
        return success(statistics); // 返回查询结果
    }

    /**
     * 查询已完成转译表中 likes 数前十数据
     *
     * @return 响应包含 likes 前十的数据
     */
    @GetMapping("/top10/likes")
    public ResponseEntity<Response> getTop10ByLikes() {
        return ResponseEntity.ok(new Response(200, "Success", translatedService.getTop10ByLikes()));
    }

    /**
     * 点赞或点踩已完成转译任务
     *
     * @param id      转译任务ID
     * @param request 请求体，包含操作类型 (like/diss)
     * @return 响应结果
     */
    @PostMapping("/{id}/like-or-diss")
    public ResponseEntity<Response> likeOrDiss(
            @PathVariable Integer id,
            @RequestBody LikeOrDissRequest request) {

        String action = request.getAction();
        if (!"like".equals(action) && !"diss".equals(action)) {
            return failure(StatusCodeEnum.ARGS_ERROR);
        }

        translatedService.likeOrDiss(id, action);
        return success();
    }

    /**
     * 获取可认领的任务列表
     *
     * @return ResponseEntity<Response>
     */
    @GetMapping("/claimable/task-list")
    public ResponseEntity<Response> getClaimableTaskList() {
        return success(taskService.getClaimableTaskList());
    }

    /**
     * 任务领取
     *
     * @param request 请求体
     * @return 响应结果
     */
    @PostMapping("/claimed/task")
    public ResponseEntity<Response> claimTask(@RequestBody ClaimTaskRequest request) {
        taskClaimedService.claimTask(request);
        return success("任务领取成功");
    }

    /**
     * 修改已认领任务
     *
     * @param request 请求体
     * @return 响应结果
     */
    @PostMapping("/update/claimed/task")
    public ResponseEntity<Response> updateClaimedTask(@RequestBody ClaimTaskRequest request) {
        taskClaimedService.updateClaimedTask(request);
        return success("任务更新成功");
    }

    /**
     * 根据任务 ID 获取待转译任务信息
     *
     * @param taskId 任务ID
     * @return 响应结果
     */
    @GetMapping("/{taskId}/task-info")
    public ResponseEntity<Response> getTaskById(@PathVariable Integer taskId) {
        Task task = taskService.getTaskById(taskId);
        if (task == null) {
            return failure("任务不存在");
        }
        return success(task);
    }
}
